home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / commontex / c / def < prev    next >
Encoding:
Text File  |  1988-04-18  |  30.4 KB  |  1,019 lines
  1. /*
  2.  *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
  3.  *    Copying of this file is granted according to the provisions 
  4.  *    specified in the file COPYING which must accompany this file.
  5.  */
  6.  
  7.  
  8. /*
  9.  *              def.c
  10.  */
  11.  
  12. #include "tex.h"
  13. #include "cmds.h"
  14. #include "heap.h"
  15. #include "io.h"
  16. #include "eq.h"
  17. #include "hash.h"
  18. #include "eqstack.h"
  19. #include "evalstack.h"
  20. #include "hash.h"
  21. #include "token.h"
  22. #include "scan.h"
  23. #include "tokenstack.h"
  24. #include "expand.h"
  25. #include "arith.h"
  26. #include "str.h"
  27. #include "box.h"
  28. #include "boxlists.h"
  29. #include "tokenlists.h"
  30. #include "file.h"
  31. #include "tfm.h"
  32. #include "dvi.h"
  33. #include "page.h"
  34. #include "print.h"
  35. #include "error.h"
  36. #include "def.h"
  37.  
  38. hword   after_token;
  39. bool    long_help_seen;
  40. val             mag_set;
  41.  
  42. #define glob    (a >= 4)
  43.  
  44. #define def(code, type, value) \
  45.         {if (glob) \
  46.                 geq_define(code, type, value); \
  47.         else eq_define(code, type, value);}
  48.  
  49. #define word_def(code, value) \
  50.         {if (glob) \
  51.                 geq_word_define(code, value); \
  52.         else eq_word_define(code, value);}
  53.  
  54. get_r_token ()
  55. {
  56. restart:
  57.         do get_token();
  58.         while (cur_tok == SPACE_TOKEN);
  59.         if (cur_cs == 0 || cur_cs > FROZEN_CONTROL_SEQUENCE) {
  60.                 print_err("Missing control sequence inserted");
  61.                 help_missing_cs();
  62.                 if (cur_cs == 0) back_input();
  63.                 cur_tok = CS_TOKEN_FLAG + FROZEN_PROTECTION;
  64.                 ins_error();
  65.                 goto restart;
  66.         }
  67. }
  68.  
  69. prefixed_command ()
  70. {
  71.         int             a;
  72.         bool    e;
  73.         fnt             f;
  74.         int             j;
  75.         int             k;
  76.         val             n;
  77.         ptr             p;
  78.         ptr             q;
  79.  
  80.         a = 0;
  81.         while (cur_cmd == PREFIX) {
  82.                 if (!odd(a / cur_chr))
  83.                         a += cur_chr;
  84.                 get_nbrx_token();
  85.                 if (cur_cmd <= MAX_NON_PREFIXED_COMMAND) {
  86.                         print_err("You can't use a prefix with `");
  87.                         print_cmd_chr(cur_cmd, cur_chr);
  88.                         print("'");
  89.                         help_prefix();
  90.                         back_error();
  91.                         return;
  92.                 }
  93.         }
  94.  
  95.         if (cur_cmd != DEF && a % 4 != 0) {
  96.                 print_err("You can't use `");
  97.                 print_esc("long");
  98.                 print("' or `");
  99.                 print_esc("outer");
  100.                 print("' with `");
  101.                 print_cmd_chr(cur_cmd, cur_chr);
  102.                 print("'");
  103.                 help_pref();
  104.                 error();
  105.         }
  106.  
  107.         if (global_defs != 0) {
  108.                 if (global_defs < 0) {
  109.                         if (glob) a -= 4;
  110.                 } else {
  111.                         if (!glob) a += 4;
  112.                 }
  113.         }
  114.  
  115.         switch (cur_cmd)
  116.         {
  117.         case SET_FONT:
  118.                 def(CUR_FONT_LOC, DATA, cur_chr);
  119.                 break;
  120.  
  121.         case DEF:
  122.                 if (odd(cur_chr) && !glob && global_defs >= 0)
  123.                         a += 4;
  124.                 e = (cur_chr >= 2);
  125.                 get_r_token();
  126.                 p = cur_cs;
  127.                 scan_toks(TRUE, e);
  128.                 def(p, CALL + (a % 4), def_ref);
  129.                 break;
  130.  
  131.         case LET:
  132.                 n = cur_chr;
  133.                 get_r_token();
  134.                 p = cur_cs;
  135.                 if (n == NORMAL) {
  136.                         do      get_token();
  137.                         while (cur_cmd == SPACER);
  138.                         if (cur_tok == OTHER_TOKEN + '=') {
  139.                                 get_token();
  140.                                 if (cur_cmd == SPACER)
  141.                                         get_token();
  142.                         }
  143.                 } else {
  144.                         get_token();
  145.                         q = cur_tok;
  146.                         get_token();
  147.                         back_input();
  148.                         cur_tok = q;
  149.                         back_input();
  150.                 }
  151.                 if (cur_cmd >= CALL)
  152.                         add_token_ref(cur_chr);
  153.                 def(p, cur_cmd, cur_chr);
  154.                 break;
  155.         
  156.         case SHORTHAND_DEF:
  157.                 n = cur_chr;
  158.                 get_r_token();
  159.                 p = cur_cs; 
  160.                 def(p, RELAX, 256);
  161.                 scan_optional_equals();
  162.                 switch ((hword) n)
  163.                 {
  164.                 case CHAR_DEF_CODE:
  165.                         scan_char_num();
  166.                         def(p, CHAR_GIVEN, (hword) cur_val);
  167.                         break;
  168.  
  169.                 case MATH_CHAR_DEF_CODE:
  170.                         scan_fifteen_bit_int();
  171.                         def(p, MATH_GIVEN, (hword) cur_val);
  172.                         break;
  173.  
  174.                 default:
  175.                         scan_eight_bit_int();
  176.                         switch ((hword) n)
  177.                         {
  178.                         case COUNT_DEF_CODE:
  179.                                 def(p, ASSIGN_INT, (hword) (COUNT_BASE + cur_val));
  180.                                 break;
  181.  
  182.                         case DIMEN_DEF_CODE:
  183.                                 def(p, ASSIGN_DIMEN, (hword) (SCALED_BASE + cur_val));
  184.                                 break;
  185.  
  186.                         case SKIP_DEF_CODE:
  187.                                 def(p, ASSIGN_GLUE, (hword) (SKIP_BASE + cur_val));
  188.                                 break;
  189.  
  190.                         case MU_SKIP_DEF_CODE:
  191.                                 def(p, ASSIGN_MU_GLUE, (hword) (MU_SKIP_BASE + cur_val));
  192.                                 break;
  193.  
  194.                         case TOKS_DEF_CODE:
  195.                                 def(p, ASSIGN_TOKS, (hword) (TOKS_BASE + cur_val));
  196.                                 break;
  197.                         }
  198.                         break;
  199.                 }
  200.                 break;
  201.  
  202.         case READ_TO_CS:
  203.                 scan_int();
  204.                 n = (int) cur_val;
  205.                 if (!scan_keyword("to")) {
  206.                         print_err("Missing `to' inserted");
  207.                         help_read_to();
  208.                         error();
  209.                 }
  210.                 get_r_token();
  211.                 p = cur_cs;
  212.                 read_toks(n, p);
  213.                 def(p, CALL, (hword) cur_val);
  214.                 break;
  215.         
  216.         case TOKS_REGISTER:
  217.         case ASSIGN_TOKS:
  218.                 q = cur_cs;
  219.                 if (cur_cmd == TOKS_REGISTER) {
  220.                         scan_eight_bit_int();
  221.                         p = TOKS_BASE + cur_val;
  222.                 } else p = cur_chr;
  223.                 scan_optional_equals();
  224.                 get_nbrx_token();
  225.                 if (cur_cmd != LEFT_BRACE) {
  226.                         if (cur_cmd == TOKS_REGISTER) {
  227.                                 scan_eight_bit_int();
  228.                                 cur_cmd = ASSIGN_TOKS;
  229.                                 cur_chr = TOKS_BASE + cur_val;
  230.                         }
  231.                         if (cur_cmd == ASSIGN_TOKS) {
  232.                                 q = equiv(cur_chr);
  233.                                 if (q == NULL) {
  234.                                         def(p, UNDEFINED_CS, NULL);
  235.                                 } else {        
  236.                                         add_token_ref(q);
  237.                                         def(p, CALL, q);
  238.                                 }
  239.                                 break;
  240.                         }
  241.                 }
  242.                 back_input();
  243.                 cur_cs = q;
  244.                 q = scan_toks(FALSE, FALSE);
  245.                 if (token_link(def_ref) == NULL) {
  246.                         def(p, UNDEFINED_CS, NULL);
  247.                         free_token(def_ref);
  248.                 } else {
  249.                         if (p == OUTPUT_ROUTINE_LOC) {
  250.                                 token_link(q) = new_token();
  251.                                 q = token_link(q);
  252.                                 token(q) = RIGHT_BRACE_TOKEN + '}';
  253.                                 q = new_token();
  254.                                 token(q) = LEFT_BRACE_TOKEN + '{';
  255.                                 token_link(q) = token_link(def_ref);
  256.                                 token_link(def_ref) = q;
  257.                         }
  258.                         def(p, CALL, def_ref);
  259.                 }
  260.                 break;
  261.  
  262.         case ASSIGN_INT:
  263.                 p = cur_chr;
  264.                 scan_optional_equals();
  265.                 scan_int();
  266.                 word_def(p, cur_val); 
  267.                 break;
  268.         
  269.         case ASSIGN_DIMEN:
  270.                 p = cur_chr;
  271.                 scan_optional_equals();
  272.                 scan_normal_dimen();
  273.                 word_def(p, cur_val); 
  274.                 break;
  275.         
  276.         case ASSIGN_GLUE:
  277.         case ASSIGN_MU_GLUE:
  278.                 p = cur_chr;
  279.                 n = cur_cmd;
  280.                 scan_optional_equals();
  281.                 if (n == ASSIGN_MU_GLUE)
  282.                         scan_glue(MU_VAL);
  283.                 else scan_glue(GLUE_VAL);
  284.                 trap_zero_glue();
  285.                 def(p, GLUE_REF, (ptr) cur_val); 
  286.                 break;
  287.         
  288.         case DEF_CODE:
  289.                 if (cur_chr == CAT_CODE_BASE)
  290.                         n = MAX_CHAR_CODE;
  291.                 else if (cur_chr == MATH_CODE_BASE)
  292.                         n = 0100000;
  293.                 else if (cur_chr == SF_CODE_BASE)
  294.                         n = 077777;
  295.                 else if (cur_chr == DEL_CODE_BASE)
  296.                         n = 077777777;
  297.                 else n = 127;
  298.                 p = cur_chr;
  299.                 scan_seven_bit_int();
  300.                 p += cur_val;
  301.                 scan_optional_equals();
  302.                 scan_int(); 
  303.                 if (cur_val < 0 && p < DEL_CODE_BASE || cur_val > n) {
  304.                         print_err("Invalid code (");
  305.                         print_val(cur_val);
  306.                         if (p < DEL_CODE_BASE)
  307.                                 print("), should be in the range 0..");
  308.                         else print("), should be at most ");
  309.                         print_val(n);
  310.                         help_code();
  311.                         error();
  312.                         cur_val = 0;
  313.                 }
  314.                 if (p < MATH_CODE_BASE) {
  315.                         def(p, DATA, (hword) cur_val);
  316.                 } else if (p < DEL_CODE_BASE) {
  317.                         def(p, DATA, (hword) hi(cur_val));
  318.                 } else word_def(p, cur_val);
  319.                 break;
  320.         
  321.         case DEF_FAMILY:
  322.                 p = cur_chr;
  323.                 scan_four_bit_int();
  324.                 p += cur_val;
  325.                 scan_optional_equals();
  326.                 scan_font_ident();
  327.                 def(p, DATA, (hword) cur_val);
  328.                 break;
  329.  
  330.         case REGISTER:
  331.         case ADVANCE:
  332.         case MULTIPLY:
  333.         case DIVIDE:
  334.                 do_register_command(a);
  335.                 break;
  336.         
  337.         case SET_BOX:
  338.                 scan_eight_bit_int();
  339.                 if (glob)
  340.                         saved(0) = BOX_FLAG + 256 + cur_val;
  341.                 else saved(0) = BOX_FLAG + cur_val;
  342.                 scan_optional_equals();
  343.                 scan_box();
  344.                 break;
  345.         
  346.         case SET_AUX:
  347.                 alter_aux();
  348.                 break;
  349.  
  350.         case SET_PREV_GRAF:
  351.                 alter_prev_graf();
  352.                 break;
  353.                 
  354.         case SET_PAGE_DIMEN:
  355.                 alter_page_so_far();
  356.                 break;
  357.  
  358.         case SET_PAGE_INT:
  359.                 alter_integer();
  360.                 break;
  361.  
  362.         case SET_BOX_DIMEN:
  363.                 alter_box_dimen();
  364.                 break;
  365.  
  366.         case SET_SHAPE:
  367.                 scan_optional_equals();
  368.                 scan_int();
  369.                 n = cur_val;
  370.                 if (n <= 0)
  371.                         p = NULL;
  372.                 else {
  373.                         p = get_node(2 * n + 1);
  374.                         info(p) = n;
  375.                         for (j = 1; j <= n; incr(j)) {
  376.                                 scan_normal_dimen();
  377.                                 mem[p + 2 * j - 1].sc = cur_val;
  378.                                 scan_normal_dimen();
  379.                                 mem[p + 2 * j].sc = cur_val;
  380.                         }
  381.                 }
  382.                 def(PAR_SHAPE_LOC, SHAPE_REF, p);
  383.                 break;
  384.         
  385.         case HYPH_DATA:
  386. #ifdef  INIT
  387.                 if (cur_chr == 1) 
  388.                         new_patterns();
  389. #else
  390.                 if (cur_chr == 1) {
  391.                         print_err("Patterns can only be loaded by INITEX");
  392.                         error();
  393.                 }
  394. #endif
  395.                 else new_hyph_exceptions();
  396.                 break;
  397.         
  398.         case ASSIGN_FONT_DIMEN:
  399.                 find_font_dimen(TRUE);
  400.                 k = cur_val;
  401.                 scan_optional_equals();
  402.                 scan_normal_dimen();
  403.                 font_info[k].sc = cur_val;
  404.                 break;
  405.         
  406.         case ASSIGN_FONT_INT:
  407.                 n = cur_chr;
  408.                 scan_font_ident();
  409.                 f = cur_val;
  410.                 scan_optional_equals();
  411.                 scan_int(); 
  412.                 if (n == 0)
  413.                         hyphen_char[f] = cur_val;
  414.                 else skew_char[f] = cur_val;
  415.                 break;
  416.  
  417.         case DEF_FONT:
  418.                 new_font(a);
  419.                 break;
  420.  
  421.         case SET_INTERACTION:
  422.                 new_interaction();
  423.                 break;
  424.  
  425.         default:
  426.                 confusion("prefix");
  427.                 break;
  428.         }
  429.         if (after_token != 0) {
  430.                 cur_tok = after_token;
  431.                 back_input();
  432.                 after_token = 0;
  433.         }
  434. } 
  435.  
  436. trap_zero_glue ()
  437. {
  438.         if (width(cur_val) == 0 &&
  439.                 stretch(cur_val) == 0 &&
  440.                 shrink(cur_val) == 0) {
  441.                 add_glue_ref(zero_glue);
  442.                 delete_glue_ref(cur_val);
  443.                 cur_val = zero_glue;
  444.         }
  445. }
  446.  
  447. do_register_command (a)
  448.         int             a;
  449. {
  450.         ptr             l;
  451.         ptr             p;
  452.         ptr             q;
  453.         ptr             r;
  454.         ptr             s;
  455.  
  456.         q = cur_cmd;
  457.         if (q != REGISTER) {
  458.                 get_x_token();
  459.                 if (cur_cmd >= ASSIGN_INT && cur_cmd <= ASSIGN_MU_GLUE) {
  460.                         l = cur_chr;
  461.                         p = cur_cmd - ASSIGN_INT;
  462.                         goto found;
  463.                 }
  464.                 if (cur_cmd != REGISTER) {
  465.                         print_err("You can't use `");
  466.                         print_cmd_chr(cur_cmd, cur_chr);
  467.                         print("' after ");
  468.                         print_cmd_chr(q, 0);
  469.                         help_register();
  470.                         error();
  471.                         return;
  472.                 }
  473.         }
  474.         p = cur_chr;
  475.         scan_eight_bit_int();
  476.         switch (p) 
  477.         {
  478.         case INT_VAL:
  479.                 l = cur_val + COUNT_BASE;
  480.                 break;
  481.  
  482.         case DIMEN_VAL:
  483.                 l = cur_val + SCALED_BASE;
  484.                 break;
  485.                 
  486.         case GLUE_VAL:
  487.                 l = cur_val + SKIP_BASE;
  488.                 break;
  489.                 
  490.         case MU_VAL:
  491.                 l = cur_val + MU_SKIP_BASE;
  492.                 break;
  493.         }
  494.  
  495. found:
  496.         if (q == REGISTER)
  497.                 scan_optional_equals();
  498.         else scan_keyword("by");
  499.         arith_error = FALSE;
  500.         if (q < MULTIPLY)  {
  501.                 if (p < GLUE_VAL) {
  502.                         if (p == INT_VAL)
  503.                                 scan_int();
  504.                         else scan_normal_dimen();
  505.                         if (q == ADVANCE)
  506.                                 cur_val += eqtb[l].i;
  507.                 } else {
  508.                         scan_glue(p);
  509.                         if (q == ADVANCE) {
  510.                                 q = new_spec(cur_val);
  511.                                 r = equiv(l);
  512.                                 delete_glue_ref(cur_val);
  513.                                 width(q) += width(r);
  514.                                 if (stretch(q) == 0)
  515.                                         stretch_order(q) = NORMAL;
  516.                                 else if (stretch_order(q) == stretch_order(r))
  517.                                         stretch(q) += stretch(r);
  518.                                 else if (stretch_order(q) < stretch_order(r) &&
  519.                                                 stretch_order(r) != 0) {
  520.                                                 stretch(q) = stretch(r);
  521.                                                 stretch_order(q) = stretch_order(r);
  522.                                 }
  523.                                 if (shrink(q) == 0)
  524.                                         shrink_order(q) = NORMAL;
  525.                                 if (shrink_order(q) == shrink_order(r))
  526.                                         shrink(q) += shrink(r);
  527.                                 else if (shrink_order(q) < shrink_order(r) &&
  528.                                                 shrink_order(r) != 0) {
  529.                                                 shrink(q) = shrink(r); 
  530.                                                 shrink_order(q) = shrink_order(r);
  531.                                 }
  532.                                 cur_val = q;
  533.                         }
  534.                 }
  535.         } else {
  536.                 scan_int();
  537.                 if (p < GLUE_VAL) {
  538.                         if (q == MULTIPLY)
  539.                                 cur_val = nx_plus_y(eqtb[l].i, cur_val, 0L);
  540.                         else cur_val = x_over_n(eqtb[l].i, cur_val);
  541.                 } else {
  542.                         s = equiv(l);
  543.                         r = new_spec(s);
  544.                         if (q == MULTIPLY) {
  545.                                 width(r) = nx_plus_y(width(s), cur_val, 0L);
  546.                                 stretch(r) = nx_plus_y(stretch(s), cur_val, 0L);
  547.                                 shrink(r) = nx_plus_y(shrink(s), cur_val, 0L);
  548.                         } else {
  549.                                 width(r) = x_over_n(width(s), cur_val);
  550.                                 stretch(r) = x_over_n(stretch(s), cur_val);
  551.                                 shrink(r) = x_over_n(shrink(s), cur_val);
  552.                         }
  553.                         cur_val = r;
  554.                 }
  555.         }
  556.         if (arith_error) {
  557.                 print_err("Arithmetic overflow");
  558.                 help_overflow();
  559.                 error();
  560.                 return;
  561.         }
  562.         if (p < GLUE_VAL) {
  563.                 word_def(l, cur_val);
  564.         } else {
  565.                 trap_zero_glue();
  566.                 def(l, GLUE_REF, (ptr) cur_val);
  567.         }
  568. }
  569.  
  570. alter_aux()
  571. {
  572.         hword   c;
  573.  
  574.         if (cur_chr != abs(mode))
  575.                 report_illegal_case();
  576.         else {
  577.                 c = cur_chr;
  578.                 scan_optional_equals();
  579.                 if (c == VMODE)  {
  580.                         scan_normal_dimen();
  581.                         prev_depth = cur_val;
  582.                 } else {
  583.                         scan_int();
  584.                         if (cur_val <= 0 || cur_val > 32767) {
  585.                                 print_err("Bad space factor");
  586.                                 help_space_factor();
  587.                                 int_error(cur_val);
  588.                         } else space_factor = cur_val;
  589.                 }
  590.         }
  591. }
  592.  
  593. alter_prev_graf ()
  594. {
  595.         ptr             p;
  596.  
  597.         nest[nest_ptr] = cur_list;
  598.         p = nest_ptr;
  599.         while (abs(nest[p].mode_field) != VMODE)        
  600.                 decr(p);
  601.         scan_optional_equals();
  602.         scan_int();
  603.         if (cur_val < 0) {
  604.                 print_err("Bad ");
  605.                 print_esc("prevgraf");
  606.                 help_prevgraf();
  607.                 int_error(cur_val);
  608.         } else {
  609.                 nest[p].pg_field = cur_val;
  610.                 cur_list = nest[nest_ptr];
  611.         }
  612. }
  613.  
  614. alter_page_so_far ()
  615. {
  616.         hword   c;
  617.  
  618.         c = cur_chr;
  619.         scan_optional_equals(); 
  620.         scan_normal_dimen();
  621.         page_so_far[c] = cur_val;
  622. }
  623.  
  624. alter_integer ()
  625. {
  626.         hword   c;
  627.         
  628.         c = cur_chr;
  629.         scan_optional_equals();
  630.         scan_int();
  631.         if (c == 0)
  632.                 dead_cycles = cur_val;
  633.         else insert_penalties = cur_val;
  634. }
  635.  
  636. alter_box_dimen ()
  637. {
  638.         byte    b;
  639.         hword   c;
  640.         
  641.         c = cur_chr;
  642.         scan_eight_bit_int();
  643.         b = cur_val; 
  644.         scan_optional_equals();
  645.         scan_normal_dimen();
  646.         if (box(b) != NULL)
  647.                 mem[box(b) + c].sc = cur_val;
  648. }
  649.  
  650. new_font (a)
  651.         int             a;
  652. {
  653.         fnt             f;
  654.         scal    s;
  655.         str             t;
  656.         ptr             u;
  657.         int             old_setting;
  658.  
  659.         if (job_name == 0)
  660.                 open_log_file();
  661.         get_r_token();
  662.         u = cur_cs;
  663.         if (u >= HASH_BASE)
  664.                 t = text(u);
  665.         else if (u >= SINGLE_BASE) {
  666.                 if (u == NULL_CS)
  667.                         t = make_string_given("FONT");
  668.                 else t = u - SINGLE_BASE;
  669.         } else {
  670.                 old_setting = selector;
  671.                 selector = NEW_STRING;
  672.                 print("FONT");
  673.                 print_str(u - ACTIVE_BASE);
  674.                 selector = old_setting;
  675.                 str_room(1);
  676.                 t = make_string();
  677.         }
  678.         def(u, SET_FONT, NULL_FONT);
  679.         scan_optional_equals();
  680.         scan_file_name();
  681.         name_in_progress = TRUE;
  682.         if (scan_keyword("at")) {
  683.                 scan_normal_dimen();
  684.                 s = cur_val;
  685.                 if (s <= 0 || s >= 01000000000) {
  686.                         print_err("Improper `at' size (");
  687.                         print_scaled(s);
  688.                         print("pt), replaced by 10pt");
  689.                         help_font_at();
  690.                         error();
  691.                         s = 10 * UNITY;
  692.                 }
  693.         } else if (scan_keyword("scaled")) {
  694.                 scan_int();
  695.                 s = -cur_val;
  696.                 if (cur_val <= 0 || cur_val > 32768) {
  697.                         print_err("Illegal magnification has been changed to 1000");
  698.                         help_font_magnification();
  699.                         int_error(cur_val);
  700.                         s = -1000;
  701.                 }
  702.         } else s = -1000;
  703.         name_in_progress = FALSE;
  704.         for (f = FONT_BASE + 1; f <= font_ptr; f++) {
  705.                 if (str_eq_str(font_name[f], cur_name) &&
  706.                         str_eq_str(font_area[f], cur_area)) {
  707.                         if (s > 0) {
  708.                                 if (s == font_size[f])
  709.                                         goto common_end;
  710.                         } else if (font_size[f] == xn_over_d(font_dsize[f], -s, 1000L))
  711.                                 goto common_end;
  712.                 }
  713.         }
  714.         f = read_font_info(u, cur_name, cur_area, s);
  715.  
  716. common_end:
  717.         equiv(u) = f;
  718.         eqtb[FONT_ID_BASE + f] = eqtb[u];
  719.         font_id_text(f) = t;
  720. }
  721.  
  722. prepare_mag ()
  723. {
  724.         if (mag_set > 0 && mag != mag_set) {
  725.                 print_err("Incompatible magnification (");
  726.                 print_val(mag);
  727.                 print(");");
  728.                 print_nl(" the previous value will be retained");
  729.                 help_mag();
  730.                 int_error(mag_set);
  731.                 geq_word_define((ptr) INT_BASE + MAG_CODE, mag_set);
  732.         }
  733.         if (mag <= 0 || mag > 32768) {
  734.                 print_err("Illegal magnification has been changed to 1000");
  735.                 help_ill_mag();
  736.                 int_error(mag);
  737.                 geq_word_define((ptr) INT_BASE + MAG_CODE, 1000L);
  738.         }
  739.         mag_set = mag;
  740. }
  741.                 
  742. new_interaction ()
  743. {
  744.         print_ln();
  745.         interaction = cur_chr;
  746.         if (interaction == BATCH_MODE)
  747.                 selector = NO_PRINT;
  748.         else selector = TERM_ONLY;
  749.         if (job_name != 0)
  750.                 selector += 2;
  751. }
  752.  
  753. do_assignments ()
  754. {
  755.         loop {
  756.                 get_nbrx_token();
  757.                 if (cur_cmd <= MAX_NON_PREFIXED_COMMAND)
  758.                         break;
  759.                 prefixed_command();
  760.         }
  761. }
  762.  
  763. clopen_stream ()
  764. {       
  765.         int             c;
  766.         int             n;
  767.  
  768.         c = cur_chr;
  769.         scan_four_bit_int();
  770.         n = cur_val; 
  771.         if (read_open[n] != CLOSED) {
  772.                 a_close(read_file[n]);
  773.                 read_open[n] = CLOSED;
  774.         }
  775.         if (c != 0) {
  776.                 scan_optional_equals();
  777.                 scan_file_name();
  778.                 if (cur_ext == null_str)
  779.                         cur_ext = str_tex;
  780.                 pack_cur_name();
  781.                 if (read_file[n] = a_open_in())
  782.                         read_open[n] = JUST_OPENED;
  783.         }
  784. }
  785.  
  786. issue_message ()
  787. {
  788.         int             c;
  789.         str             s;
  790.         int             old_setting;
  791.  
  792.         c = cur_chr;
  793.         scan_toks(FALSE, TRUE);
  794.         old_setting = selector;
  795.         selector = NEW_STRING;
  796.         token_show(def_ref);
  797.         selector = old_setting;
  798.         flush_list(def_ref);
  799.         str_room(1);
  800.         s = make_string();
  801.         if (c == 0) {
  802.                 if (term_offset + length(s) > MAX_PRINT_LINE - 2)
  803.                         print_ln();
  804.                 else if (term_offset > 0 || file_offset > 0)
  805.                         print_char(' ');
  806.                 print_str(s);
  807.                 update_terminal();
  808.         } else {
  809.                 print_err("");
  810.                 print_str(s);
  811.                 if (err_help != NULL)
  812.                         use_err_help = TRUE;
  813.                 else if (long_help_seen)
  814.                         help_err_msg();
  815.                 else {
  816.                         if (interaction < ERROR_STOP_MODE)
  817.                                 long_help_seen = TRUE;
  818.                         help_poirot();
  819.                 }
  820.                 error();
  821.                 use_err_help = FALSE;
  822.         }
  823.         flush_string();
  824. }
  825.  
  826. give_err_help ()
  827. {
  828.         token_show(err_help);
  829. }
  830.  
  831. shift_case ()
  832. {
  833.         ptr             b;
  834.         byte    c;
  835.         ptr             p;
  836.         hword   t;
  837.  
  838.         b = cur_chr;
  839.         scan_toks(FALSE, FALSE);
  840.         for (p = token_link(def_ref); p != NULL; p = token_link(p)) {
  841.                 t = token(p);
  842.                 if (t < CS_TOKEN_FLAG + SINGLE_BASE) {
  843.                         if (t >= CS_TOKEN_FLAG)
  844.                                 t -= ACTIVE_BASE;
  845.                         c = t % 256;
  846.                         if (c < 128 && equiv(b + c) != 0)
  847.                                 t = 256 * (t / 256) + equiv(b + c);
  848.                         if (t >= CS_TOKEN_FLAG)
  849.                                 token(p) = t + ACTIVE_BASE;
  850.                         else token(p) = t;
  851.                 }
  852.         }
  853.         back_list(token_link(def_ref));
  854.         free_token(def_ref);
  855. }
  856.  
  857. show_whatever ()
  858. {
  859.         switch (cur_chr)
  860.         {
  861.         case SHOW_LISTS:
  862.                 begin_diagnostic();
  863.                 show_activities();
  864.                 break;
  865.  
  866.         case SHOW_BOX_CODE:
  867.                 scan_eight_bit_int();
  868.                 begin_diagnostic();
  869.                 print_nl("> \\box");
  870.                 print_val(cur_val);
  871.                 print_char('=');
  872.                 if (box(cur_val) == NULL)
  873.                         print("void");
  874.                 else show_box(box(cur_val));
  875.                 break;
  876.         
  877.         case SHOW_CODE:
  878.                 get_token();
  879.                 print_nl("> ");
  880.                 if (cur_cs != 0) {
  881.                         sprint_cs(cur_cs);
  882.                         print_char('=');
  883.                 }
  884.                 print_meaning();
  885.                 goto common_end;
  886.                 break;
  887.         
  888.         default:
  889.                 the_toks();
  890.                 print_nl("> ");
  891.                 token_show(temp_toks);
  892.                 flush_list(token_link(temp_toks));
  893.                 goto common_end;
  894.                 break;
  895.         }
  896.         end_diagnostic(TRUE);
  897.         print_err("OK");
  898.         if (selector == TERM_AND_LOG && tracing_online <= 0) {
  899.                 selector = TERM_ONLY;
  900.                 print(" (see the transcript file)");
  901.                 selector = TERM_AND_LOG;
  902.         }
  903.  
  904. common_end:
  905.         if (interaction < ERROR_STOP_MODE) {
  906.                 help0();
  907.                 decr(error_count);
  908.         } else if (tracing_online > 0)
  909.                 help_show_online();
  910.         else help_show();
  911.         error();
  912. }
  913.  
  914. /*
  915.  *      Help text
  916.  */
  917.  
  918. help_missing_cs ()
  919. {
  920.         help5("Please don't say `\\def cs{...}', say `\\def\\cs{...}'.",
  921.         "I've inserted an inaccessible control sequence so that your",
  922.         "definition will be completed without mixing me up too badly.",
  923.         "You can recover graciously from this error, if you're",
  924.         "careful; see exercise 27.2 in The TeXbook.");
  925. }
  926.  
  927. help_prefix ()
  928. {
  929.         help1("I'll pretend that you didn't say \\long or \\outer or \\global.");
  930. }
  931.  
  932. help_pref ()
  933. {
  934.         help1("I'll pretend that you didn't say \\long or \\outer here.");
  935. }
  936.  
  937. help_read_to ()
  938. {
  939.         help2("You should have said `\\read<number> to \\cs'.",
  940.         "I'm going to look for the \\cs now.");
  941. }
  942.  
  943. help_code ()
  944. {
  945.         help1("I'm going to use 0 instead of that illegal code value.");
  946. }
  947.  
  948. help_register ()
  949. {
  950.         help1("I'm forgetting what you said and not changing anything.");
  951. }
  952.  
  953. help_space_factor ()
  954. {
  955.         help1("I allow only values in the range 1..32767 here.");
  956. }
  957.  
  958. help_prevgraf ()
  959. {
  960.         help1("I allow only nonnegative values here.");
  961. }
  962.  
  963. help_overflow ()
  964. {
  965.         help2(" I can't carry out that multiplication or division,",
  966.         "since the result is out of range.");
  967. }
  968.  
  969. help_font_at ()
  970. {
  971.         help2("I can only handle fonts at positive sizes that are",
  972.         "less than 2048pt, so I've changed what you said to 10pt.");
  973. }
  974.  
  975. help_font_magnification ()
  976. {
  977.         help1("The magnification ratio must be between 1 and 32768.");
  978. }
  979.  
  980. help_mag()
  981. {
  982.         help2("I can handle only one magnification ratio per job. So I've",
  983.         "reverted to the magnification you used earlier on this run.");
  984. }
  985.  
  986. help_ill_mag ()
  987. {
  988.         help1("The magnification ratio must be between 1 and 32768.");
  989. }
  990.  
  991. help_err_msg ()
  992. {
  993.         help1("(That was another \\errmessage.)");
  994. }
  995.  
  996. help_poirot ()
  997. {
  998.         help4("This error message was generated by an \\errmessage",
  999.         "command, so I can't give any explicit help.",
  1000.         "Pretend that you're Hercule Poirot: examine all clues,",/*DIFF*/
  1001.         "and deduce the truth by order and method.");
  1002. }
  1003.  
  1004. help_show_online ()
  1005. {
  1006.         help3("This isn't an error message; I'm just \\showing something.",
  1007.         "Type `I\\show...' to show more (e.g., \\show\\cs,",
  1008.         "\\showthe\\count10, \\showbox255, \\showlists).");
  1009. }
  1010.  
  1011. help_show ()
  1012. {
  1013.         help5("This isn't an error message; I'm just \\showing something.",
  1014.         "Type `I\\show...' to show more (e.g., \\show\\cs,",
  1015.         "\\showthe\\count10, \\showbox255, \\showlists).",
  1016.         "And type `I\\tracingonline=1\\show...' to show boxes and",
  1017.         "lists on your terminal as well as in the transcript file.");
  1018. }
  1019.